// 导入全局认证管理器和API
import { authManager } from '../../api/auth-manager';
import api from '../../api/index';
const i18n = require('../../i18n/index');

Page({
  // 认证状态监听器移除函数
  authStateUnsubscribe: null as (() => void) | null,
  // 温馨提示定时器
  healthTipTimer: null as number | null,

  data: {
    // i18n 文案
    l10n: {
      title: '',
      greeting: '',
      guest: '',
      loginPromptMessage: '',
      loginPromptDesc: '',
      loginPromptBtn: '',
      dropSubtitle: '',
      completed: '',
      target: '',
      remaining: '',
      hourlyTitle: '',
      weeklyStatsTitle: '',
      weeklyTotal: '',
      waterLogsTitle: '',
      todayLogs: ''
    },
    // 头部组件标题
    pageTitle: '',

    // Header data 
    userName: '',
    healthTip: '多喝水，少熬夜～',
    showCycleInfo: false,
    cyclePhaseIcon: '🌙',
    cyclePhase: '',
    cycleDay: 0,
    cycleSuggestion: '',
    // 天气相关数据
    weatherInfo: {
      temperature: 0,
      weather: '',
      city: ''
    },

    // Login
    isLoggedIn: false,

    // Weekly stats
    weeklyAmount: '0 ml',
    weeklyDays: [
      { name: '一', amount: '0' },
      { name: '二', amount: '0' },
      { name: '三', amount: '0' },
      { name: '四', amount: '0' },
      { name: '五', amount: '0' },
      { name: '六', amount: '0' },
      { name: '日', amount: '0' }
    ],

    // Today progress
    todayDrink: 0,
    waterGoal: 2000,
    waterProgress: 0,
    remainingWater: 2000,
    todayLogs: [] as any[], // 添加今日记录数组

    // Hour grid
    hourlyGrid: [] as any[],

    // Records
    waterRecords: [] as any[],
    allWaterLog: [] as any[],
    pageSize: 10,
    pageNo: 1,
    hasMoreRecords: false,
    isLoadingMore: false,

    // Add modal
    showAddWaterModal: false,
    quickAmounts: [150, 200, 300, 500],
    selectedAmount: 200,
    customAmount: '',

    // 下拉刷新/设备搜索区域所需数据
    triggered: false,
    scanDevices: [] as any[]
  },

  onLoad(options: any) {
    console.log('[IndexPage] onLoad 参数:', options);

    // 初始化多语言与导航标题
    this.updateTexts();

    // 初始化温馨提示
    this.initHealthTip();
    
    // 检查是否来自公众号
    if (options && options.from === 'official') {
      console.log('[IndexPage] ✅ 检测到来自公众号参数 from=official');
      console.log('[IndexPage] 🎯 设置来自公众号标识');
      
      // 使用多重保障的存储设置
      console.log('[IndexPage] 🔄 开始设置公众号标识存储');
      
      // 方法1: 同步设置
      wx.setStorageSync('fromOfficialAccount', true);
      console.log('[IndexPage] ✅ 方法1-同步存储完成');
      
      // 方法2: 异步设置作为备份
      wx.setStorage({
        key: 'fromOfficialAccount',
        data: true,
        success: () => console.log('[IndexPage] ✅ 方法2-异步存储完成'),
        fail: (err) => console.error('[IndexPage] ❌ 异步存储失败:', err)
      });
      
      // 延迟验证存储结果
      setTimeout(() => {
        const stored = wx.getStorageSync('fromOfficialAccount');
        console.log('[IndexPage] 🔍 延迟验证存储结果:', stored, typeof stored);
        
        if (stored === true) {
          console.log('[IndexPage] ✅ 存储验证通过');
        } else {
          console.warn('[IndexPage] ⚠️ 存储验证失败，尝试重新设置');
          wx.setStorageSync('fromOfficialAccount', true);
        }
      }, 100);
      
      // 🆕 检查用户登录状态，只有未登录的用户才跳转到登录页
      console.log('[IndexPage] 🔍 检查用户登录状态');
      const isLoggedIn = authManager.isAuthenticated();
      console.log('[IndexPage] 📋 用户登录状态:', isLoggedIn);
      
      if (!isLoggedIn) {
        console.log('[IndexPage] 🚀 用户未登录，跳转到登录页');
        wx.navigateTo({
          url: '/pages/login/login?from=official',
          success: () => {
            console.log('[IndexPage] ✅ 成功跳转到登录页');
          },
          fail: (err) => {
            console.error('[IndexPage] ❌ 跳转失败:', err);
          }
        });
        return; // 直接返回，不继续执行后续初始化逻辑
      } else {
        console.log('[IndexPage] ✅ 用户已登录，继续正常初始化页面');
        // 继续执行正常的页面初始化逻辑
      }
    }

    // 设置认证状态监听器
    this.authStateUnsubscribe = authManager.addAuthStateListener((isLoggedIn: boolean, user: any) => {
      console.log('[首页] 登录状态变化:', { isLoggedIn, user });
      this.setData({ 
        isLoggedIn,
        userName: user?.nickname || user?.username || ''
      });
      // 登录状态或用户名变化后，刷新标题文案
      this.updateTexts();
      
      // 如果用户已登录，加载饮水目标
      if (isLoggedIn) {
        this.loadWaterGoal();
      }
    });

    this.restoreFromStorage()
    this.initHourGrid()
    this.updateProgress()
    this.refreshWeeklyFromLogs()
    
    // 如果已经登录，立即加载饮水目标
    if (authManager.isAuthenticated()) {
      this.loadWaterGoal();
    }
  },

  onShow() {
    // 更新 tabBar 选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 0
      });
    }

    // 每次回到首页刷新多语言标题
    this.updateTexts();

    // 检查是否有待处理的登录跳转
    const pendingLoginRedirect = wx.getStorageSync('pendingLoginRedirect');
    if (pendingLoginRedirect) {
      // 清除标记
      wx.removeStorageSync('pendingLoginRedirect');
      console.log('[IndexPage] 检测到待处理的登录跳转，正在跳转到登录页面');
      
      // 跳转到登录页面
      wx.navigateTo({
        url: '/pages/login/login',
        success: () => {
          console.log('[IndexPage] 成功跳转到登录页面');
        },
        fail: (err) => {
          console.error('[IndexPage] 跳转到登录页面失败:', err);
        }
      });
      return;
    }
    
    // 刷新温馨提示
    this.updateHealthTip();
    
    // 加载数据
    this.restoreFromStorage();
    
    // 更新进度和每小时状态
    this.updateProgress();
    
    // 刷新本周统计
    this.refreshWeeklyFromLogs();
    
    // 如果已登录，刷新饮水目标
    if (authManager.isAuthenticated()) {
      this.loadWaterGoal();
    }
  },

  // 更新多语言文案
  updateTexts(): void {
    const t = (k: string) => i18n.t(`home.${k}`);
    const l10n = {
      title: t('title'),
      greeting: t('greeting'),
      guest: t('guest'),
      loginPromptMessage: t('loginPromptMessage'),
      loginPromptDesc: t('loginPromptDesc'),
      loginPromptBtn: t('loginPromptBtn'),
      dropSubtitle: t('dropSubtitle'),
      completed: t('completed'),
      target: t('target'),
      remaining: t('remaining'),
      hourlyTitle: t('hourlyTitle'),
      weeklyStatsTitle: t('weeklyStatsTitle'),
      weeklyTotal: t('weeklyTotal'),
      waterLogsTitle: t('waterLogsTitle'),
      todayLogs: t('todayLogs'),
      timesSuffix: t('timesSuffix')
    };
    const name = this.data.userName || l10n.guest;
    const pageTitle = (l10n.greeting || '').replace('{name}', name);
    this.setData({ l10n, pageTitle });
    try { wx.setNavigationBarTitle({ title: l10n.title }); } catch (e) {}
  },

  onUnload() {
    // 清理认证状态监听器
    if (this.authStateUnsubscribe) {
      this.authStateUnsubscribe();
      this.authStateUnsubscribe = null;
    }
    
    // 清理温馨提示定时器
    if (this.healthTipTimer) {
      clearInterval(this.healthTipTimer);
      this.healthTipTimer = null;
    }
  },

  // 🌟 新增：初始化温馨提示系统
  initHealthTip() {
    console.log('[温馨提示] 初始化温馨提示系统');
    
    // 立即更新一次
    this.updateHealthTip();
    
    // 设置定时器，每10分钟更新一次
    this.healthTipTimer = setInterval(() => {
      this.updateHealthTip();
    }, 10 * 60 * 1000); // 10分钟
  },

  // 🌟 新增：更新温馨提示
  updateHealthTip() {
    const now = new Date();
    const hour = now.getHours();
    const minute = now.getMinutes();
    const month = now.getMonth() + 1; // 0-11 -> 1-12
    const date = now.getDate();
    
    console.log('[温馨提示] 当前时间:', `${hour}:${minute}`, '月份:', month);
    
    // 获取天气信息（优先使用真实数据）
    this.getWeatherInfo().then(() => {
      const tip = this.generateHealthTip(hour, month, date);
      console.log('[温馨提示] 生成新提示（真实天气）:', tip);
      this.setData({ healthTip: tip });
    }).catch(() => {
      // 天气获取失败时，仍然生成提示
      const tip = this.generateHealthTip(hour, month, date);
      console.log('[温馨提示] 生成新提示（备用天气）:', tip);
      this.setData({ healthTip: tip });
    });
  },



  // 🌟 新增：获取天气信息（使用真实API）
  getWeatherInfo(): Promise<void> {
    return new Promise((resolve, reject) => {
      // 先尝试从header-nav组件获取天气数据
      const headerNavComponent = this.selectComponent('header-nav');
      if (headerNavComponent) {
        const headerWeatherData = headerNavComponent.data;
        if (headerWeatherData.weatherTemp && headerWeatherData.weatherTemp !== '--') {
          // 使用header-nav的真实天气数据
          const realWeather = {
            temperature: parseInt(headerWeatherData.weatherTemp) || 20,
            weather: headerWeatherData.weatherCondition || '晴',
            city: headerWeatherData.weatherCity || '当前城市'
          };
          console.log('[天气] 使用header-nav真实天气数据:', realWeather);
          this.setData({ weatherInfo: realWeather });
          resolve();
          return;
        }
      }

      // 如果header-nav数据不可用，直接调用天气API
      wx.getSetting({
        success: (res) => {
          if (res.authSetting['scope.userLocation'] === false) {
            // 无位置权限，使用模拟数据
            this.useFallbackWeather();
            resolve();
          } else {
            this.getLocationWeather().then(resolve).catch(() => {
              this.useFallbackWeather();
              resolve();
            });
          }
        },
        fail: () => {
          this.useFallbackWeather();
          resolve();
        }
      });
    });
  },

  // 获取位置并调用天气API
  getLocationWeather(): Promise<void> {
    return new Promise((resolve, reject) => {
      wx.getLocation({
        type: 'gcj02',
        success: (location) => {
          const { latitude, longitude } = location;
          console.log('[天气] 获取位置成功:', { latitude, longitude });
          
          // 调用真实天气API
          wx.request({
            url: `https://xhd.szxhdkj.com/api/weather/location?latitude=${latitude}&longitude=${longitude}`,
            timeout: 10000,
            success: (res) => {
              console.log('[天气] API响应:', res);
              if (res.statusCode === 200 && res.data && typeof res.data === 'object') {
                const responseData = res.data as any;
                if (responseData.data) {
                  this.handleRealWeatherData(responseData.data);
                  resolve();
                } else {
                  console.warn('[天气] API响应格式异常，使用备用数据');
                  reject();
                }
              } else {
                console.warn('[天气] API响应异常，使用备用数据');
                reject();
              }
            },
            fail: (err) => {
              console.error('[天气] API请求失败:', err);
              reject();
            }
          });
        },
        fail: (err) => {
          console.log('[天气] 获取位置失败:', err);
          reject();
        }
      });
    });
  },

  // 处理真实天气数据
  handleRealWeatherData(data: any) {
    const weather = data.data || data;
    const realWeather = {
      temperature: weather.temperature || 20,
      weather: weather.condition || '晴',
      city: weather.city || '当前城市'
    };
    
    console.log('[天气] 处理真实天气数据:', realWeather);
    this.setData({ weatherInfo: realWeather });
    
    // 缓存天气数据（避免频繁请求）
    const today = new Date().toISOString().split('T')[0];
    wx.setStorageSync(`index_weather_${today}`, {
      ...realWeather,
      time: Date.now()
    });
  },

  // 使用备用天气数据
  useFallbackWeather() {
    // 先尝试使用缓存的天气数据
    const today = new Date().toISOString().split('T')[0];
    const cached = wx.getStorageSync(`index_weather_${today}`);
    
    if (cached && cached.time && (Date.now() - cached.time) < 6 * 60 * 60 * 1000) {
      console.log('[天气] 使用缓存的天气数据:', cached);
      this.setData({ 
        weatherInfo: {
          temperature: cached.temperature,
          weather: cached.weather,
          city: cached.city
        }
      });
      return;
    }

    // 最后使用模拟数据
    console.log('[天气] 使用模拟天气数据');
    const mockWeather = this.getMockWeather();
    this.setData({ weatherInfo: mockWeather });
  },

  // 🌟 新增：获取模拟天气数据（实际项目中可以接入真实天气API）
  getMockWeather() {
    const now = new Date();
    const hour = now.getHours();
    const month = now.getMonth() + 1;
    
    // 根据月份模拟季节性天气
    let temperature = 20;
    let weather = '晴';
    
    if (month >= 3 && month <= 5) {
      // 春季
      temperature = Math.floor(Math.random() * 10) + 15; // 15-25度
      weather = ['晴', '多云', '小雨'][Math.floor(Math.random() * 3)];
    } else if (month >= 6 && month <= 8) {
      // 夏季
      temperature = Math.floor(Math.random() * 10) + 25; // 25-35度
      weather = ['晴', '多云', '雷阵雨'][Math.floor(Math.random() * 3)];
    } else if (month >= 9 && month <= 11) {
      // 秋季
      temperature = Math.floor(Math.random() * 10) + 10; // 10-20度
      weather = ['晴', '多云', '小雨'][Math.floor(Math.random() * 3)];
    } else {
      // 冬季
      temperature = Math.floor(Math.random() * 10) + 0; // 0-10度
      weather = ['晴', '多云', '雪'][Math.floor(Math.random() * 3)];
    }
    
    return {
      temperature,
      weather,
      city: '当前城市'
    };
  },

  // 🌟 新增：生成智能健康提示
  generateHealthTip(hour: number, month: number, date: number): string {
    const weather = this.data.weatherInfo;
    const temperature = weather.temperature;
    
    // 时间段分类
    let timeOfDay = '';
    if (hour >= 5 && hour < 9) {
      timeOfDay = 'morning';
    } else if (hour >= 9 && hour < 12) {
      timeOfDay = 'forenoon';
    } else if (hour >= 12 && hour < 14) {
      timeOfDay = 'noon';
    } else if (hour >= 14 && hour < 18) {
      timeOfDay = 'afternoon';
    } else if (hour >= 18 && hour < 22) {
      timeOfDay = 'evening';
    } else {
      timeOfDay = 'night';
    }
    
    // 季节分类
    let season = '';
    if (month >= 3 && month <= 5) season = 'spring';
    else if (month >= 6 && month <= 8) season = 'summer';
    else if (month >= 9 && month <= 11) season = 'autumn';
    else season = 'winter';
    
    // 温度相关提示
    const temperatureTips = this.getTemperatureTips(temperature, season);
    
    // 时间相关提示
    const timeTips = this.getTimeTips(timeOfDay, hour);
    
    // 天气相关提示
    const weatherTips = this.getWeatherTips(weather.weather, season);
    
    // 特殊日期提示
    const specialTips = this.getSpecialDateTips(month, date);
    
    // 健康小知识提示
    const healthKnowledgeTips = this.getHealthKnowledgeTips();
    
    // 根据时间权重选择提示类型
    let selectedTips: string[] = [];
    
    // 特殊日期优先级最高
    if (specialTips.length > 0 && Math.random() < 0.4) {
      selectedTips = specialTips;
    }
    // 早晨和晚上时间相关提示权重高
    else if ((timeOfDay === 'morning' || timeOfDay === 'night') && timeTips.length > 0 && Math.random() < 0.5) {
      selectedTips = timeTips;
    }
    // 极端温度时，温度相关提示权重高
    else if ((temperature < 10 || temperature > 30) && temperatureTips.length > 0 && Math.random() < 0.6) {
      selectedTips = temperatureTips;
    }
    // 恶劣天气时，天气相关提示权重高
    else if ((weather.weather === '雨' || weather.weather === '雪' || weather.weather === '雷阵雨') && weatherTips.length > 0 && Math.random() < 0.5) {
      selectedTips = weatherTips;
    }
    // 随机展示健康小知识
    else if (Math.random() < 0.3) {
      selectedTips = healthKnowledgeTips;
    }
    // 默认混合所有提示
    else {
      selectedTips = [...temperatureTips, ...timeTips, ...weatherTips];
    }
    
    // 如果没有合适的提示，使用所有提示
    if (selectedTips.length === 0) {
      selectedTips = [...temperatureTips, ...timeTips, ...weatherTips, ...healthKnowledgeTips];
    }
    
    const randomTip = selectedTips[Math.floor(Math.random() * selectedTips.length)];
    
    return this.translateTip(randomTip || '多喝水，保持健康～');
  },

  // 🌟 新增：获取温度相关提示
  getTemperatureTips(temp: number, season: string): string[] {
    const tips: string[] = [];
    
    if (temp < 5) {
      tips.push('天气寒冷，多喝温水暖身体～');
      tips.push('低温天气，热水有助于血液循环～');
      tips.push('寒冷天气记得多补充热水～');
    } else if (temp >= 5 && temp < 15) {
      tips.push('天气微凉，温水最舒适～');
      tips.push('适宜的温度，记得定时饮水～');
      tips.push('凉爽天气也要保持饮水习惯～');
    } else if (temp >= 15 && temp < 25) {
      tips.push('温度适宜，是饮水的好时光～');
      tips.push('舒适的天气，别忘了补充水分～');
      tips.push('温度刚好，多喝水更健康～');
    } else if (temp >= 25 && temp < 30) {
      tips.push('天气渐热，记得多补水～');
      tips.push('温度升高，身体需要更多水分～');
      tips.push('暖和天气，增加饮水量更健康～');
    } else {
      tips.push('高温天气，务必多喝水防中暑～');
      tips.push('炎热天气，水分流失快要及时补充～');
      tips.push('酷暑难耐，清凉的水是最好的伙伴～');
    }
    
    return tips;
  },

  // 🌟 新增：获取时间相关提示
  getTimeTips(timeOfDay: string, hour: number): string[] {
    const tips: string[] = [];
    
    switch (timeOfDay) {
      case 'morning':
        tips.push('🌅 早安！一杯温水开启美好的一天～');
        tips.push('🌞 晨光正好，记得先喝杯水唤醒身体～');
        tips.push('☀️ 新的一天开始了，补充水分很重要～');
        tips.push('🌄 早晨时光，一杯水让你精神焕发～');
        break;
      case 'forenoon':
        tips.push('🌤️ 上午工作忙碌，别忘了喝水休息～');
        tips.push('⏰ 工作间隙，来杯水提提神～');
        tips.push('💼 忙碌的上午，水分补充不能少～');
        break;
      case 'noon':
        tips.push('🍽️ 午餐时间，饭前一杯水助消化～');
        tips.push('☀️ 正午时分，补充水分很重要～');
        tips.push('🥗 午餐时光，记得搭配充足的水分～');
        break;
      case 'afternoon':
        tips.push('🌇 下午时光，一杯水赶走疲劳～');
        tips.push('☕ 下午茶时间，不如来杯清水～');
        tips.push('💻 下午工作，保持水分充足更有活力～');
        break;
      case 'evening':
        tips.push('🌆 傍晚时分，适量补水很重要～');
        tips.push('🍽️ 晚餐前，记得喝点水～');
        tips.push('🌙 夜幕降临，别忘了补充水分～');
        break;
      case 'night':
        if (hour >= 22) {
          tips.push('🌙 夜深了，少量饮水，早点休息～');
          tips.push('⭐ 夜晚时光，适量喝水不影响睡眠～');
          tips.push('🛌 准备休息了，记得明天要多喝水～');
        } else {
          tips.push('🌃 夜晚降临，适量补水很重要～');
          tips.push('🌟 夜晚时光，保持水分平衡～');
        }
        break;
    }
    
    return tips;
  },

  // 🌟 新增：获取天气相关提示
  getWeatherTips(weather: string, season: string): string[] {
    const tips: string[] = [];
    
    switch (weather) {
      case '晴':
        tips.push('☀️ 阳光明媚，记得多喝水防晒伤～');
        tips.push('🌞 晴空万里，补充水分享受好天气～');
        tips.push('☀️ 好天气配好心情，别忘了多喝水～');
        break;
      case '多云':
        tips.push('☁️ 多云天气，适量饮水保持活力～');
        tips.push('🌤️ 云朵飘飘，水分补充不能忘～');
        tips.push('⛅ 多云的天空，记得保持饮水习惯～');
        break;
      case '小雨':
      case '雨':
        tips.push('🌧️ 雨天湿润，也要记得补充水分～');
        tips.push('☔ 听雨声品清水，别有一番风味～');
        tips.push('🌦️ 雨天在家，一杯温水很舒适～');
        break;
      case '雷阵雨':
        tips.push('⛈️ 雷雨天气，在家喝水最安全～');
        tips.push('🌩️ 雷电交加，室内补水更放心～');
        break;
      case '雪':
        tips.push('❄️ 雪花纷飞，热水暖身又暖心～');
        tips.push('⛄ 雪天寒冷，温水是最好的伴侣～');
        tips.push('🌨️ 飘雪的日子，来杯热水吧～');
        break;
    }
    
    return tips;
  },

  // 🌟 新增：获取特殊日期提示
  getSpecialDateTips(month: number, date: number): string[] {
    const tips: string[] = [];
    
    // 节气相关
    if (month === 3 && date >= 20) {
      tips.push('🌸 春分时节，多喝水迎接春天的活力～');
    } else if (month === 6 && date >= 21) {
      tips.push('☀️ 夏至已到，充足水分度过炎炎夏日～');
    } else if (month === 9 && date >= 22) {
      tips.push('🍂 秋分时节，温润的水分最养人～');
    } else if (month === 12 && date >= 21) {
      tips.push('❄️ 冬至来临，温水暖身过寒冬～');
    }
    
    // 传统节日
    if (month === 1 && date === 1) {
      tips.push('🎊 新年快乐！新的一年从多喝水开始～');
    } else if (month === 2 && date === 14) {
      tips.push('💝 情人节快乐！爱自己从多喝水开始～');
    } else if (month === 3 && date === 8) {
      tips.push('🌺 女神节快乐！美丽从内而外，多喝水～');
    } else if (month === 5 && date === 1) {
      tips.push('🎉 劳动节快乐！劳动之余记得补充水分～');
    } else if (month === 6 && date === 1) {
      tips.push('🧒 儿童节快乐！保持童心，多喝水～');
    } else if (month === 10 && date === 1) {
      tips.push('🇨🇳 国庆节快乐！为祖国干杯，多喝水～');
    } else if (month === 12 && date === 25) {
      tips.push('🎄 圣诞快乐！节日的礼物是健康的身体～');
    }
    
    // 月初月末
    if (date <= 3) {
      tips.push('📅 月初新开始，养成喝水好习惯～');
      tips.push('🌟 新月伊始，给身体充满活力的水分～');
    } else if (date >= 28) {
      tips.push('📆 月末总结时，别忘了总结饮水量～');
      tips.push('📊 月末了，看看这个月喝了多少水～');
    }
    
    // 周末
    const now = new Date();
    const dayOfWeek = now.getDay();
    if (dayOfWeek === 0 || dayOfWeek === 6) {
      tips.push('🎉 周末时光，放松的同时记得多喝水～');
      tips.push('🏖️ 休闲时光，一杯好水配美好时光～');
      tips.push('☕ 周末慢生活，从一杯清水开始～');
    } else if (dayOfWeek === 1) {
      tips.push('💪 周一加油！新的一周从多喝水开始～');
    } else if (dayOfWeek === 5) {
      tips.push('🎊 周五啦！坚持到底，别忘了喝水～');
    }
    
    // 特殊数字日期
    if (date === 8) {
      tips.push('8️⃣ 发财日！健康是最大的财富，多喝水～');
    } else if (date === 18) {
      tips.push('🍀 要发日！身体发棒，记得多喝水～');
    } else if (date === 6 || date === 16 || date === 26) {
      tips.push('6️⃣ 六六大顺！顺便多喝点水～');
    }
    
    return tips;
  },

  // 🌟 新增：获取健康小知识提示
  getHealthKnowledgeTips(): string[] {
    const healthTips = [
      '💡 小知识：成年人每天需要1500-2000ml水分～',
      '🧠 大脑含水量达75%，缺水会影响思维～',
      '💪 肌肉含水量达76%，充足水分助力运动～',
      '🌡️ 体温调节需要水分，多喝水防中暑～',
      '🫀 血液含水量达90%，水分充足血液流畅～',
      '✨ 皮肤水润有光泽，秘诀就是多喝水～',
      '🔋 新陈代谢需要水分参与，多喝水更有活力～',
      '🧘‍♀️ 充足水分有助于缓解压力和疲劳～',
      '🌙 睡前适量饮水，但不要过量影响睡眠～',
      '🏃‍♂️ 运动前中后都要补充水分，预防脱水～'
    ];
    
    return healthTips;
  },

  // 🌟 新增：将中文提示翻译为当前语言
  translateTip(text: string): string {
    const lang = i18n.getLang && i18n.getLang();
    if (!text || lang === 'zh-CN') return text;

    // 简体 → 繁体映射
    const hkMap: { [k: string]: string } = {
      '多喝水，保持健康～': '多喝水，保持健康～',
      '天气寒冷，多喝温水暖身体～': '天氣寒冷，多喝溫水暖身體～',
      '低温天气，热水有助于血液循环～': '低溫天氣，熱水有助於血液循環～',
      '寒冷天气记得多补充热水～': '寒冷天氣記得多補充熱水～',
      '天气微凉，温水最舒适～': '天氣微涼，溫水最舒適～',
      '适宜的温度，记得定时饮水～': '適宜的溫度，記得定時飲水～',
      '凉爽天气也要保持饮水习惯～': '涼爽天氣也要保持飲水習慣～',
      '温度适宜，是饮水的好时光～': '溫度適宜，是飲水的好時光～',
      '舒适的天气，别忘了补充水分～': '舒適的天氣，別忘了補充水分～',
      '温度刚好，多喝水更健康～': '溫度剛好，多喝水更健康～',
      '天气渐热，记得多补水～': '天氣漸熱，記得多補水～',
      '温度升高，身体需要更多水分～': '溫度升高，身體需要更多水分～',
      '暖和天气，增加饮水量更健康～': '暖和天氣，增加飲水量更健康～',
      '高温天气，务必多喝水防中暑～': '高溫天氣，務必多喝水防中暑～',
      '炎热天气，水分流失快要及时补充～': '炎熱天氣，水分流失快要及時補充～',
      '酷暑难耐，清凉的水是最好的伙伴～': '酷暑難耐，清涼的水是最好的夥伴～',
      '🌅 早安！一杯温水开启美好的一天～': '🌅 早安！一杯溫水開啟美好的一天～',
      '🌞 晨光正好，记得先喝杯水唤醒身体～': '🌞 晨光正好，記得先喝杯水喚醒身體～',
      '☀️ 新的一天开始了，补充水分很重要～': '☀️ 新的一天開始了，補充水分很重要～',
      '🌄 早晨时光，一杯水让你精神焕发～': '🌄 早晨時光，一杯水讓你精神煥發～',
      '🌤️ 上午工作忙碌，别忘了喝水休息～': '🌤️ 上午工作忙碌，別忘了喝水休息～',
      '⏰ 工作间隙，来杯水提提神～': '⏰ 工作間隙，來杯水提提神～',
      '💼 忙碌的上午，水分补充不能少～': '💼 忙碌的上午，水分補充不能少～',
      '🍽️ 午餐时间，饭前一杯水助消化～': '🍽️ 午餐時間，飯前一杯水助消化～',
      '☀️ 正午时分，补充水分很重要～': '☀️ 正午時分，補充水分很重要～',
      '🥗 午餐时光，记得搭配充足的水分～': '🥗 午餐時光，記得搭配充足的水分～',
      '🌇 下午时光，一杯水赶走疲劳～': '🌇 下午時光，一杯水趕走疲勞～',
      '☕ 下午茶时间，不如来杯清水～': '☕ 下午茶時間，不如來杯清水～',
      '💻 下午工作，保持水分充足更有活力～': '💻 下午工作，保持水分充足更有活力～',
      '🌆 傍晚时分，适量补水很重要～': '🌆 傍晚時分，適量補水很重要～',
      '🍽️ 晚餐前，记得喝点水～': '🍽️ 晚餐前，記得喝點水～',
      '🌙 夜幕降临，别忘了补充水分～': '🌙 夜幕降臨，別忘了補充水分～',
      '🌙 夜深了，少量饮水，早点休息～': '🌙 夜深了，少量飲水，早點休息～',
      '⭐ 夜晚时光，适量喝水不影响睡眠～': '⭐ 夜晚時光，適量喝水不影響睡眠～',
      '🛌 准备休息了，记得明天要多喝水～': '🛌 準備休息了，記得明天要多喝水～',
      '🌃 夜晚降临，适量补水很重要～': '🌃 夜晚降臨，適量補水很重要～',
      '🌟 夜晚时光，保持水分平衡～': '🌟 夜晚時光，保持水分平衡～',
      '☀️ 阳光明媚，记得多喝水防晒伤～': '☀️ 陽光明媚，記得多喝水防曬傷～',
      '🌞 晴空万里，补充水分享受好天气～': '🌞 晴空萬里，補充水分享受好天氣～',
      '☀️ 好天气配好心情，别忘了多喝水～': '☀️ 好天氣配好心情，別忘了多喝水～',
      '☁️ 多云天气，适量饮水保持活力～': '☁️ 多雲天氣，適量飲水保持活力～',
      '🌤️ 云朵飘飘，水分补充不能忘～': '🌤️ 雲朵飄飄，水分補充不能忘～',
      '⛅ 多云的天空，记得保持饮水习惯～': '⛅ 多雲的天空，記得保持飲水習慣～',
      '🌧️ 雨天湿润，也要记得补充水分～': '🌧️ 雨天濕潤，也要記得補充水分～',
      '☔ 听雨声品清水，别有一番风味～': '☔ 聽雨聲品清水，別有一番風味～',
      '🌦️ 雨天在家，一杯温水很舒适～': '🌦️ 雨天在家，一杯溫水很舒適～',
      '⛈️ 雷雨天气，在家喝水最安全～': '⛈️ 雷雨天氣，在家喝水最安全～',
      '🌩️ 雷电交加，室内补水更放心～': '🌩️ 雷電交加，室內補水更放心～',
      '❄️ 雪花纷飞，热水暖身又暖心～': '❄️ 雪花紛飛，熱水暖身又暖心～',
      '⛄ 雪天寒冷，温水是最好的伴侣～': '⛄ 雪天寒冷，溫水是最好的伴侶～',
      '🌨️ 飘雪的日子，来杯热水吧～': '🌨️ 飄雪的日子，來杯熱水吧～',
      '🌸 春分时节，多喝水迎接春天的活力～': '🌸 春分時節，多喝水迎接春天的活力～',
      '☀️ 夏至已到，充足水分度过炎炎夏日～': '☀️ 夏至已到，充足水分度過炎炎夏日～',
      '🍂 秋分时节，温润的水分最养人～': '🍂 秋分時節，溫潤的水分最養人～',
      '❄️ 冬至来临，温水暖身过寒冬～': '❄️ 冬至來臨，溫水暖身過寒冬～',
      '🎊 新年快乐！新的一年从多喝水开始～': '🎊 新年快樂！新的一年從多喝水開始～',
      '💝 情人节快乐！爱自己从多喝水开始～': '💝 情人節快樂！愛自己從多喝水開始～',
      '🌺 女神节快乐！美丽从内而外，多喝水～': '🌺 女神節快樂！美麗由內而外，多喝水～',
      '🎉 劳动节快乐！劳动之余记得补充水分～': '🎉 勞動節快樂！勞動之餘記得補充水分～',
      '🧒 儿童节快乐！保持童心，多喝水～': '🧒 兒童節快樂！保持童心，多喝水～',
      '🇨🇳 国庆节快乐！为祖国干杯，多喝水～': '🇨🇳 國慶節快樂！為祖國乾杯，多喝水～',
      '🎄 圣诞快乐！节日的礼物是健康的身体～': '🎄 聖誕快樂！節日的禮物是健康的身體～',
      '📅 月初新开始，养成喝水好习惯～': '📅 月初新開始，養成喝水好習慣～',
      '🌟 新月伊始，给身体充满活力的水分～': '🌟 新月伊始，給身體充滿活力的水分～',
      '📆 月末总结时，别忘了总结饮水量～': '📆 月末總結時，別忘了總結飲水量～',
      '📊 月末了，看看这个月喝了多少水～': '📊 月末了，看看這個月喝了多少水～',
      '🎉 周末时光，放松的同时记得多喝水～': '🎉 週末時光，放鬆的同時記得多喝水～',
      '🏖️ 休闲时光，一杯好水配美好时光～': '🏖️ 休閒時光，一杯好水配美好時光～',
      '☕ 周末慢生活，从一杯清水开始～': '☕ 週末慢生活，從一杯清水開始～',
      '💪 周一加油！新的一周从多喝水开始～': '💪 週一加油！新的一週從多喝水開始～',
      '🎊 周五啦！坚持到底，别忘了喝水～': '🎊 週五啦！堅持到底，別忘了喝水～',
      '8️⃣ 发财日！健康是最大的财富，多喝水～': '8️⃣ 發財日！健康是最大的財富，多喝水～',
      '🍀 要发日！身体发棒，记得多喝水～': '🍀 要發日！身體發棒，記得多喝水～',
      '6️⃣ 六六大顺！顺便多喝点水～': '6️⃣ 六六大順！順便多喝點水～'
    };

    // 简体 → 英文映射
    const enMap: { [k: string]: string } = {
      '多喝水，保持健康～': 'Drink more water and stay healthy!',
      '天气寒冷，多喝温水暖身体～': 'It\'s cold. Warm water keeps you comfy.',
      '低温天气，热水有助于血液循环～': 'In low temperatures, warm water helps blood circulation.',
      '寒冷天气记得多补充热水～': 'Cold weather? Refill with warm water.',
      '天气微凉，温水最舒适～': 'A bit cool. Warm water feels best.',
      '适宜的温度，记得定时饮水～': 'Pleasant weather. Remember to drink regularly.',
      '凉爽天气也要保持饮水习惯～': 'Cool days still need steady hydration.',
      '温度适宜，是饮水的好时光～': 'Perfect temperature for a good drink of water.',
      '舒适的天气，别忘了补充水分～': 'Nice weather. Don\'t forget to hydrate.',
      '温度刚好，多喝水更健康～': 'Just right—more water, more health.',
      '天气渐热，记得多补水～': 'Getting hot—drink more water.',
      '温度升高，身体需要更多水分～': 'As it warms up, your body needs more water.',
      '暖和天气，增加饮水量更健康～': 'Warm days call for extra hydration.',
      '高温天气，务必多喝水防中暑～': 'High heat—hydrate well to prevent heatstroke.',
      '炎热天气，水分流失快要及时补充～': 'Hot weather drains water fast—replenish in time.',
      '酷暑难耐，清凉的水是最好的伙伴～': 'Scorching heat—cool water is your best buddy.',
      '🌅 早安！一杯温水开启美好的一天～': '🌅 Good morning! Start the day with warm water.',
      '🌞 晨光正好，记得先喝杯水唤醒身体～': '🌞 Morning light—wake up your body with water.',
      '☀️ 新的一天开始了，补充水分很重要～': '☀️ A new day—hydration matters.',
      '🌄 早晨时光，一杯水让你精神焕发～': '🌄 Morning water boosts your energy.',
      '🌤️ 上午工作忙碌，别忘了喝水休息～': '🌤️ Busy morning—remember water breaks.',
      '⏰ 工作间隙，来杯水提提神～': '⏰ Take a sip during breaks to refresh.',
      '💼 忙碌的上午，水分补充不能少～': '💼 Stay hydrated through a busy morning.',
      '🍽️ 午餐时间，饭前一杯水助消化～': '🍽️ Before lunch, a glass of water aids digestion.',
      '☀️ 正午时分，补充水分很重要～': '☀️ Noon—top up your water.',
      '🥗 午餐时光，记得搭配充足的水分～': '🥗 Lunchtime—keep water alongside your meal.',
      '🌇 下午时光，一杯水赶走疲劳～': '🌇 Afternoon—water helps fight fatigue.',
      '☕ 下午茶时间，不如来杯清水～': '☕ Tea time? Plain water also works.',
      '💻 下午工作，保持水分充足更有活力～': '💻 Afternoon work—hydration keeps you active.',
      '🌆 傍晚时分，适量补水很重要～': '🌆 Evening—moderate hydration matters.',
      '🍽️ 晚餐前，记得喝点水～': '🍽️ Drink some water before dinner.',
      '🌙 夜幕降临，别忘了补充水分～': '🌙 Night falls—don\'t forget water.',
      '🌙 夜深了，少量饮水，早点休息～': '🌙 It\'s late—small sips and rest early.',
      '⭐ 夜晚时光，适量喝水不影响睡眠～': '⭐ Drink moderately at night for better sleep.',
      '🛌 准备休息了，记得明天要多喝水～': '🛌 Time to rest—drink more tomorrow.',
      '🌃 夜晚降临，适量补水很重要～': '🌃 Night time—proper hydration matters.',
      '🌟 夜晚时光，保持水分平衡～': '🌟 Keep water balance at night.',
      '☀️ 阳光明媚，记得多喝水防晒伤～': '☀️ Sunny day—drink more water and avoid sunburn.',
      '🌞 晴空万里，补充水分享受好天气～': '🌞 Clear skies—hydrate and enjoy.',
      '☀️ 好天气配好心情，别忘了多喝水～': '☀️ Good weather, good mood—drink more water.',
      '☁️ 多云天气，适量饮水保持活力～': '☁️ Cloudy—moderate hydration keeps you active.',
      '🌤️ 云朵飘飘，水分补充不能忘～': '🌤️ Clouds drift—don\'t forget water.',
      '⛅ 多云的天空，记得保持饮水习惯～': '⛅ Cloudy sky—keep the habit of drinking water.',
      '🌧️ 雨天湿润，也要记得补充水分～': '🌧️ Rainy but still hydrate.',
      '☔ 听雨声品清水，别有一番风味～': '☔ Enjoy the rain with a glass of water.',
      '🌦️ 雨天在家，一杯温水很舒适～': '🌦️ Rainy day at home—warm water comforts.',
      '⛈️ 雷雨天气，在家喝水最安全～': '⛈️ Thunderstorm—stay in and drink water.',
      '🌩️ 雷电交加，室内补水更放心～': '🌩️ Lightning—indoor hydration is safer.',
      '❄️ 雪花纷飞，热水暖身又暖心～': '❄️ Snowing—hot water warms body and heart.',
      '⛄ 雪天寒冷，温水是最好的伴侣～': '⛄ Snowy and cold—warm water is best.',
      '🌨️ 飘雪的日子，来杯热水吧～': '🌨️ Snowy days—have some hot water.',
      '🌸 春分时节，多喝水迎接春天的活力～': '🌸 Vernal equinox—hydrate for spring energy.',
      '☀️ 夏至已到，充足水分度过炎炎夏日～': '☀️ Summer solstice—plenty of water for hot days.',
      '🍂 秋分时节，温润的水分最养人～': '🍂 Autumn equinox—gentle hydration is best.',
      '❄️ 冬至来临，温水暖身过寒冬～': '❄️ Winter solstice—warm water for the cold.',
      '🎊 新年快乐！新的一年从多喝水开始～': '🎊 Happy New Year! Start with more water.',
      '💝 情人节快乐！爱自己从多喝水开始～': '💝 Happy Valentine\'s! Self-care starts with water.',
      '🌺 女神节快乐！美丽从内而外，多喝水～': '🌺 Women\'s Day! Beauty starts from hydration.',
      '🎉 劳动节快乐！劳动之余记得补充水分～': '🎉 Labor Day! Hydrate during breaks.',
      '🧒 儿童节快乐！保持童心，多喝水～': '🧒 Children\'s Day! Stay playful and hydrated.',
      '🇨🇳 国庆节快乐！为祖国干杯，多喝水～': '🇨🇳 National Day! Cheers with water.',
      '🎄 圣诞快乐！节日的礼物是健康的身体～': '🎄 Merry Christmas! Health is the best gift.',
      '📅 月初新开始，养成喝水好习惯～': '📅 New month—build the water habit.',
      '🌟 新月伊始，给身体充满活力的水分～': '🌟 New month—fill your body with vitality (water).',
      '📆 月末总结时，别忘了总结饮水量～': '📆 Month-end—review your water intake.',
      '📊 月末了，看看这个月喝了多少水～': '📊 Month-end—see how much you drank.',
      '🎉 周末时光，放松的同时记得多喝水～': '🎉 Weekend—relax and hydrate.',
      '🏖️ 休闲时光，一杯好水配美好时光～': '🏖️ Leisure time—good water for good times.',
      '☕ 周末慢生活，从一杯清水开始～': '☕ Slow weekend—start with a glass of water.',
      '💪 周一加油！新的一周从多喝水开始～': '💪 Monday—fuel the week with more water.',
      '🎊 周五啦！坚持到底，别忘了喝水～': '🎊 Friday—keep it up and drink water.',
      '8️⃣ 发财日！健康是最大的财富，多喝水～': '8️⃣ Fortune day! Health is wealth—drink more.',
      '🍀 要发日！身体发棒，记得多喝水～': '🍀 Lucky day! Stay strong with more water.',
      '6️⃣ 六六大顺！顺便多喝点水～': '6️⃣ Double six! Have some more water.'
    };

    if (lang === 'zh-HK') {
      return hkMap[text] || text;
    }
    if (lang === 'en-US') {
      return enMap[text] || text;
    }
    return text;
  },

  // 加载饮水目标
  loadWaterGoal() {
    const self = this;
    
    console.log('[首页] 开始获取饮水目标');
    
    // 调用后端API获取用户信息（包含饮水目标）
    api.getUserInfo().then((res: any) => {
      console.log('[首页] 获取用户信息和饮水目标成功:', res);
      
      if (res && res.data && res.data.data) {
        const userData = res.data.data;
        const dailyGoal = userData.dailyGoal || 2000;
        
        // 更新饮水目标
        self.setData({ waterGoal: dailyGoal });
        
        // 缓存饮水目标
        wx.setStorageSync('waterGoal', dailyGoal.toString());
        
        console.log('[首页] 饮水目标已更新:', dailyGoal, 'ml');
        
        // 更新进度
        self.updateProgress();
      }
    }).catch((error: any) => {
      console.error('[首页] 获取饮水目标失败:', error);
      
      // 使用本地缓存作为备用
      try {
        const waterGoal = wx.getStorageSync('waterGoal') || 2000;
        self.setData({ waterGoal: parseInt(waterGoal) });
        self.updateProgress();
      } catch (e) {
        console.error('读取本地饮水目标失败:', e);
      }
    });
  },

  restoreFromStorage() {
    try {
      // 使用全局认证管理器
      const isLoggedIn = authManager.isAuthenticated();
      const currentUser = authManager.getCurrentUser();
      const logs = wx.getStorageSync('waterLogs') || [];
      const userName = currentUser?.nickname || currentUser?.username || '';
      
      // 获取今日记录
      const todayKey = this.getTodayKey();
      const todayLogs = logs.filter((it: any) => it.date === todayKey);
      
      this.setData({ 
        isLoggedIn, 
        allWaterLog: logs, 
        userName,
        todayLogs // 设置今日记录数组
      });
      
      console.log('[首页] 加载记录: 总数', logs.length, '今日记录', todayLogs.length);
    } catch (e) {
      console.error('恢复存储数据失败:', e);
    }
  },

  // Header/Login
  goToLogin() {
    wx.navigateTo({ url: '/pages/login/login' })
  },

  // Navigation methods
  goToStats() {
    wx.navigateTo({ url: '/pages/stats/stats' })
  },

  goToWater() {
    wx.navigateTo({ url: '/pages/water/water' })
  },

  // Hourly grid 6-22 后接 23,00,01
  initHourGrid() {
    const hours: any[] = []
    for (let h = 6; h <= 22; h++) {
      hours.push({ hour: h, label: `${h}:00`, status: 'todo' })
    }
    // 尾部追加 23:00、00:00、01:00
    hours.push({ hour: 23, label: `23:00`, status: 'todo' })
    hours.push({ hour: 0, label: `00:00`, status: 'todo' })
    hours.push({ hour: 1, label: `01:00`, status: 'todo' })
    this.setData({ hourlyGrid: hours })
    
    // 初始化完成后立即更新状态
    this.updateHourlyStatus()
  },

  // 更新每小时达标状态
  updateHourlyStatus() {
    const todayLogs = this.getTodayLogs()
    const now = new Date()
    const currentHour = now.getHours()
    const hourlyGrid = [...this.data.hourlyGrid]
    
    // 按小时统计饮水量
    const hourlyWater: { [key: number]: number } = {}
    todayLogs.forEach((log: any) => {
      if (log.time) {
        const hour = parseInt(log.time.split(':')[0])
        if (!hourlyWater[hour]) {
          hourlyWater[hour] = 0
        }
        hourlyWater[hour] += log.amount || 0
      }
    })
    
    // 更新每小时状态
    hourlyGrid.forEach((item: any) => {
      const hour = item.hour
      const waterAmount = hourlyWater[hour] || 0
      
      if (waterAmount > 0) {
        // 有饮水记录，标记为已完成
        item.status = 'completed'
      } else {
        // 判断时间是否已过
        let hourPassed = false
        
        if (hour >= 6 && hour <= 22) {
          // 正常时间段 6:00-22:00
          hourPassed = hour < currentHour
                 } else if (hour === 23) {
           // 23:00 - 当前时间是第二天才算错过
           hourPassed = currentHour >= 0 && currentHour < 6
        } else if (hour === 0) {
          // 00:00 - 只有当前时间超过0点时才算错过
          hourPassed = currentHour > 0
        } else if (hour === 1) {
          // 01:00 - 只有当前时间超过1点时才算错过
          hourPassed = currentHour > 1
        }
        
        if (hourPassed) {
          // 时间已过但没有饮水记录，标记为错过
          item.status = 'missed'
        } else {
          // 未到时间或当前时间段，保持待完成
          item.status = 'pending'
        }
      }
    })
    
    console.log('[每小时状态] 当前时间:', currentHour + ':' + now.getMinutes(), '状态更新:', hourlyGrid.map(h => `${h.label}:${h.status}`).join(', '))
    this.setData({ hourlyGrid })
  },

  // Progress
  updateProgress() {
    const today = this.getTodayLogs()
    const total = today.reduce((s: number, it: any) => s + (it.amount || 0), 0)
    const progress = Math.min(100, Math.round((total / this.data.waterGoal) * 100))
    const remaining = Math.max(0, this.data.waterGoal - total) // 确保不为负数
    this.setData({ 
      todayDrink: total, 
      waterProgress: progress,
      remainingWater: remaining,
      todayLogs: today // 更新今日记录数组
    })
    
    // 更新每小时达标状态
    this.updateHourlyStatus()
  },

  // Logs
  getTodayKey(): string {
    const now = new Date()
    const y = now.getFullYear()
    const m = `${now.getMonth() + 1}`.padStart(2, '0')
    const d = `${now.getDate()}`.padStart(2, '0')
    return `${y}-${m}-${d}`
  },
  getTodayLogs(): any[] {
    const key = this.getTodayKey()
    return (this.data.allWaterLog || []).filter((it: any) => it.date === key)
  },
  formatTime(date: Date): string {
    const h = `${date.getHours()}`.padStart(2, '0')
    const m = `${date.getMinutes()}`.padStart(2, '0')
    return `${h}:${m}`
  },
  handleQuickAdd() { this.setData({ showAddWaterModal: true }) },
  closeAddWaterModal() { this.setData({ showAddWaterModal: false }) },
  selectAmount(e: any) {
    const amount = Number(e.currentTarget.dataset.amount)
    if (amount === 0) { this.setData({ selectedAmount: 0 }) } else { this.setData({ selectedAmount: amount }) }
  },
  addWater() {
    let amount = this.data.selectedAmount
    if (amount === 0) { amount = Number(this.data.customAmount || 0) }
    if (!amount || amount <= 0) { wx.showToast({ title: '请输入有效饮水量', icon: 'none' }); return }
    
    const now = new Date()
    const record = { 
      id: `${now.getTime()}`, 
      amount, 
      time: this.formatTime(now), 
      type: '饮水', 
      date: this.getTodayKey() 
    }
    
    console.log('[添加饮水] 新记录:', record)
    
    const all = [record, ...this.data.allWaterLog]
    const todayLogs = this.getTodayLogs()
    this.setData({ 
      allWaterLog: all, 
      todayLogs: todayLogs,
      showAddWaterModal: false, 
      customAmount: '', 
      selectedAmount: 200 
    })
    
    // 保存到本地存储
    try { 
      wx.setStorageSync('waterLogs', all)
      console.log('[添加饮水] 已保存到本地存储，总记录数:', all.length)
    } catch (e) {
      console.error('[添加饮水] 保存到本地存储失败:', e)
    }
    
    // 更新各项数据
    this.updateProgress()
    this.refreshWeeklyFromLogs()
    this.refreshWaterRecords()
    
    wx.showToast({ title: `添加 ${amount}ml 成功！`, icon: 'success' })
  },
  
  refreshWaterRecords() {
    const today = this.getTodayLogs()
    const pageNo = this.data.pageNo
    const pageSize = this.data.pageSize
    const slice = today.slice(0, pageNo * pageSize)
    this.setData({ waterRecords: slice, hasMoreRecords: slice.length < today.length })
  },
  loadMoreRecords() {
    if (!this.data.hasMoreRecords || this.data.isLoadingMore) return
    this.setData({ isLoadingMore: true })
    setTimeout(() => {
      this.setData({ pageNo: this.data.pageNo + 1, isLoadingMore: false })
      this.refreshWaterRecords()
    }, 400)
  },

  // Weekly aggregation
  refreshWeeklyFromLogs() {
    const logs = this.data.allWaterLog || []
    const now = new Date()
    
    // 计算本周一（周一为一周的开始）
    const dow = now.getDay() // 0=周日, 1=周一, ..., 6=周六
    const daysFromMonday = dow === 0 ? 6 : dow - 1 // 周日需要特殊处理
    const monday = new Date(now)
    monday.setDate(now.getDate() - daysFromMonday)
    monday.setHours(0, 0, 0, 0)
    
    console.log('[本周统计] 当前日期:', now.toLocaleDateString())
    console.log('[本周统计] 本周一:', monday.toLocaleDateString())
    console.log('[本周统计] 饮水记录总数:', logs.length)
    
    const daily: number[] = new Array(7).fill(0)
    
    logs.forEach((log: any) => {
      if (!log.date) return
      
      // 解析日期 YYYY-MM-DD
      const logDate = new Date(log.date + 'T00:00:00') // 添加时间避免时区问题
      const dayDiff = Math.floor((logDate.getTime() - monday.getTime()) / (24 * 60 * 60 * 1000))
      
      console.log('[本周统计] 记录日期:', log.date, '天数差:', dayDiff, '数量:', log.amount)
      
      if (dayDiff >= 0 && dayDiff < 7) {
        daily[dayDiff] += log.amount || 0
      }
    })
    
    const names = ['一', '二', '三', '四', '五', '六', '日']
    const weeklyDays = names.map((n, i) => ({ name: n, amount: `${daily[i]}` }))
    const totalAmount = daily.reduce((s, v) => s + v, 0)
    const weeklyAmount = `${totalAmount} ml`
    
    console.log('[本周统计] 每日数据:', daily)
    console.log('[本周统计] 本周总量:', weeklyAmount)
    
    this.setData({ weeklyDays, weeklyAmount })
  },

  // 下拉刷新相关回调（用于页面底部添加设备区域）
  onPulling() {
    // 可根据下拉距离做动画，这里保持简洁
  },
  onRefresh() {
    this.setData({ triggered: true })
    // 模拟扫描设备，避免模板事件未实现导致报错
    setTimeout(() => {
      const mockDevices = [
        { device: { deviceId: 'A1:B2:C3:D4', RSSI: -52 } },
        { device: { deviceId: 'E5:F6:G7:H8', RSSI: -67 } }
      ]
      this.setData({ scanDevices: mockDevices, triggered: false })
      try { wx.stopPullDownRefresh() } catch (e) {}
    }, 600)
  },
  onRestore() {
    this.setData({ triggered: false })
  },
  onAbort() {
    this.setData({ triggered: false })
  },

  // 点击设备连接（示例占位）
  onConnectDev(e: any) {
    const dev = e?.currentTarget?.dataset?.dev
    wx.showModal({
      title: '连接设备',
      content: `尝试连接设备：${dev?.device?.deviceId || '未知'}`,
      showCancel: true,
      confirmText: '确定'
    })
  }
})



